const userModel = require('../models/userModel');
const jwt = require('jsonwebtoken');
const ApiResponse = require('../utils/response');
const logger = require('../utils/logger');

const userController = {
  /**
   * 用户注册
   */
  async register(req, res, next) {
    try {
      const { phone, password, name, id_card, area_id } = req.body;

      // 验证必填字段
      if (!phone || !password) {
        return ApiResponse.badRequest(res, '手机号和密码为必填项');
      }

      // 验证手机号格式
      const phoneRegex = /^1[3-9]\d{9}$/;
      if (!phoneRegex.test(phone)) {
        return ApiResponse.badRequest(res, '手机号格式不正确');
      }

      // 验证密码长度
      if (password.length < 8) {
        return ApiResponse.badRequest(res, '密码长度不能少于8位');
      }

      // 验证身份证号格式（如果提供）
      if (id_card) {
        const idCardRegex = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/;
        if (!idCardRegex.test(id_card)) {
          return ApiResponse.badRequest(res, '身份证号格式不正确');
        }
      }

      // 检查手机号是否已注册
      const exists = await userModel.isPhoneExists(phone);
      if (exists) {
        return ApiResponse.badRequest(res, '该手机号已被注册');
      }

      // 如果提供了区域ID，验证区域是否存在且为县/区级（level=3）
      if (area_id) {
        const { query } = require('../config/db');
        const areaResult = await query('SELECT level FROM areas WHERE id = ?', [area_id]);
        if (areaResult.length === 0) {
          return ApiResponse.badRequest(res, '所选地区不存在');
        }
        if (areaResult[0].level !== 3) {
          return ApiResponse.badRequest(res, '请选择县/区级地区');
        }
      }

      // 创建用户
      const userId = await userModel.create({
        phone,
        password,
        name: name || null,
        id_card: id_card || null,
        area_id: area_id || null
      });

      logger.info('用户注册成功', { userId, phone });

      // 生成token
      const token = jwt.sign(
        { userId, phone, type: 'user' },
        process.env.JWT_SECRET || 'xiqu-secret-key',
        { expiresIn: process.env.JWT_EXPIRES_IN || '7d' }
      );

      return ApiResponse.created(res, {
        token,
        user: {
          id: userId,
          phone,
          name: name || null
        }
      }, '注册成功');

    } catch (error) {
      logger.error('用户注册失败', { error: error.message, body: req.body });
      next(error);
    }
  },

  /**
   * 用户登录
   */
  async login(req, res, next) {
    try {
      const { phone, password } = req.body;

      // 验证必填字段
      if (!phone || !password) {
        return ApiResponse.badRequest(res, '手机号和密码为必填项');
      }

      // 查找用户
      const user = await userModel.findByPhone(phone);
      if (!user) {
        return ApiResponse.unauthorized(res, '手机号或密码错误');
      }

      // 检查账号状态
      if (user.status === '禁用') {
        return ApiResponse.forbidden(res, '账号已被禁用，请联系管理员');
      }

      // 验证密码
      const isPasswordValid = await userModel.verifyPassword(password, user.password);
      if (!isPasswordValid) {
        return ApiResponse.unauthorized(res, '手机号或密码错误');
      }

      // 更新最后登录时间
      await userModel.updateLastLogin(user.id);

      // 生成token
      const token = jwt.sign(
        { userId: user.id, phone: user.phone, type: 'user' },
        process.env.JWT_SECRET || 'xiqu-secret-key',
        { expiresIn: process.env.JWT_EXPIRES_IN || '7d' }
      );

      logger.info('用户登录成功', { userId: user.id, phone });

      // 返回用户信息（不包含密码）
      const { password: _, ...userInfo } = user;

      return ApiResponse.success(res, {
        token,
        user: userInfo
      }, '登录成功');

    } catch (error) {
      logger.error('用户登录失败', { error: error.message });
      next(error);
    }
  },

  /**
   * 获取当前用户信息
   */
  async getCurrentUser(req, res, next) {
    try {
      const userId = req.user.userId;

      const user = await userModel.findById(userId);
      if (!user) {
        return ApiResponse.notFound(res, '用户不存在');
      }

      // 删除密码字段
      const { password, ...userInfo } = user;

      return ApiResponse.success(res, userInfo);

    } catch (error) {
      logger.error('获取用户信息失败', { error: error.message });
      next(error);
    }
  },

  /**
   * 更新用户信息
   */
  async updateProfile(req, res, next) {
    try {
      const userId = req.user.userId;
      const { name, id_card, area_id } = req.body;

      const updateData = {};

      // 只更新提供的字段
      if (name !== undefined) {
        updateData.name = name;
      }

      if (id_card !== undefined) {
        if (id_card) {
          // 验证身份证号格式
          const idCardRegex = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/;
          if (!idCardRegex.test(id_card)) {
            return ApiResponse.badRequest(res, '身份证号格式不正确');
          }
        }
        updateData.id_card = id_card;
      }

      if (area_id !== undefined) {
        if (area_id) {
          // 验证区域是否存在且为县/区级
          const { query } = require('../config/db');
          const areaResult = await query('SELECT level FROM areas WHERE id = ?', [area_id]);
          if (areaResult.length === 0) {
            return ApiResponse.badRequest(res, '所选地区不存在');
          }
          if (areaResult[0].level !== 3) {
            return ApiResponse.badRequest(res, '请选择县/区级地区');
          }
        }
        updateData.area_id = area_id;
      }

      if (Object.keys(updateData).length === 0) {
        return ApiResponse.badRequest(res, '没有可更新的字段');
      }

      const success = await userModel.update(userId, updateData);
      if (!success) {
        return ApiResponse.serverError(res, '更新失败');
      }

      logger.info('用户信息更新成功', { userId, updateData });

      // 获取更新后的用户信息
      const user = await userModel.findById(userId);
      const { password, ...userInfo } = user;

      return ApiResponse.success(res, userInfo, '更新成功');

    } catch (error) {
      logger.error('更新用户信息失败', { error: error.message });
      next(error);
    }
  },

  /**
   * 修改密码
   */
  async changePassword(req, res, next) {
    try {
      const userId = req.user.userId;
      const { old_password, new_password } = req.body;

      // 验证必填字段
      if (!old_password || !new_password) {
        return ApiResponse.badRequest(res, '旧密码和新密码为必填项');
      }

      // 验证新密码长度
      if (new_password.length < 8) {
        return ApiResponse.badRequest(res, '新密码长度不能少于8位');
      }

      // 查找用户
      const user = await userModel.findById(userId);
      if (!user) {
        return ApiResponse.notFound(res, '用户不存在');
      }

      // 验证旧密码
      const isPasswordValid = await userModel.verifyPassword(old_password, user.password);
      if (!isPasswordValid) {
        return ApiResponse.unauthorized(res, '旧密码错误');
      }

      // 更新密码
      const success = await userModel.update(userId, { password: new_password });
      if (!success) {
        return ApiResponse.serverError(res, '密码修改失败');
      }

      logger.info('用户密码修改成功', { userId });

      return ApiResponse.success(res, null, '密码修改成功');

    } catch (error) {
      logger.error('修改密码失败', { error: error.message });
      next(error);
    }
  }
};

module.exports = userController;

